package Main2;

import javax.xml.soap.SAAJResult;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Locale;
import java.util.Scanner;
import java.util.stream.Stream;

public class Main123 {
    //数组中出现次数超过一半的数字
    public int MoreThanHalfNum_Solution (int[] numbers) {
        //1.给数组排序
        Arrays.sort(numbers);
        int mid = numbers.length / 2;
        int count = 0;
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[mid] == numbers[i]) count++;
        }
        if (count > mid) return numbers[mid];
        return -1;
    }
    //字符串中连续最长的字符串
    /*思路：定义两个空字符串，如果是遍历到数字字符此时就加入第一个字符串
    * 如果遍历完了数字字符，此时就把第一个字符串放到第二个字符串中，然后
    * 继续遍历，当又遍历完一个数字串之后此时就和第二个字符串比长度，如果长度比
    * 第二个字符串长此时就更新第二个字符串，否则就清空第一个字符串中的内容
    * 注意：需要在循环之后再比较一遍两个字符串长度，否则如果是最后一个数字串长，
    * 此时循环进不来，无法将第一个字符串的内容给到第二个字符串*/
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) {
            String str = scan.nextLine().toLowerCase();
            String cur = null;
            String ret = null;
            int i = 0;
            for (; i < str.length(); i++) {
                char ch = str.charAt(i);
                if (ch >= '0' && ch <= '9') {
                    cur += ch + "";
                }else {
                   if (cur.length() > ret.length()) {
                       ret = cur;
                   }else {
                       cur = null;
                   }
                }
            }
            if (i == str.length() && cur.length() > ret.length()) {
                ret = cur;
            }
            System.out.println(ret.toString());
        }
    }

    //删除公共字符  输入：They are students.
    //aeiou   输出：Thy r stdnts.
    //思路：把s2中的字符录入一个map中，如果s1不包含这个字符就拼接到一个新的字符串中，
    //最后输出这个新的字符串就把s1中含有s2的字符去掉了
    public static void main1(String[] args) {
        Scanner scan = new Scanner(System.in);
        String s1 = scan.nextLine();
        String s2 = scan.nextLine();
        HashMap<Character, Integer> map = new HashMap<>();
        //首先把s2中的字符串录入map中，之后再看s1中是否有map中的字符
        for (int i = 0; i < s2.length(); i++) {
            if (map.get(s2.charAt(i)) == null) {
                map.put(s2.charAt(i), 1);
            }else {
                map.put(s2.charAt(i), map.get(s2.charAt(i)) + 1);
            }
        }
        String str = "";
        for (int i = 0; i < s1.length(); i++) {
            if (map.get(s1.charAt(i)) == null) str += s1.charAt(i);
        }
        System.out.println(str);
    }
    //组队竞赛
    public static void main2(String[] args) {
        Scanner scan = new Scanner(System.in);
        while (scan.hasNextInt()) {
            int n = scan.nextInt();
            int[] arr = new int[3 * n];
            long sum = 0;
            //把数组录入进来
            for (int i = 0; i < n; i++) {
                arr[i] = scan.nextInt();
            }
            Arrays.sort(arr);
            for (int i = 0; i < n; i++) {
                sum += arr[arr.length - 2*(i-1)];
            }
            System.out.println(sum);
        }
    }
    //倒置字符串  输入
    //I like beijing.  输出
    //beijing. like I
    /*思路: 先将整体字符串进行逆置，然后单个单词再进行逆置，但是StringBuilder
    和StringBuffer中的reverse方法不能传参，只能是整体的字符串进行逆置,所以需要自己写一个逆置方法*/
    private static void reverse(char[] chars, int start, int end) {
        while (start < end) {
            char tmp = chars[start];
            chars[start] = chars[end];
            chars[end] = tmp;
            start++;
            end--;
        }
    }
    public static void main3(String[] args) {
        Scanner scan = new Scanner(System.in);
        while (scan.hasNextLine()) {
            String s = scan.nextLine();
            char[] ch = s.toCharArray();
            int len = ch.length;
            reverse(ch, 0, len - 1);
            int i = 0;//遍历ch数组
            while (i < len) {
                int j = i;
                while (j < len && ch[j] != ' ') {
                    j++;
                }
                if (j < len) {
                    reverse(ch, i, j - 1);
                    i = j + 1;
                }else {
                    reverse(ch, i, j - 1);
                    i = j;
                }
            }
            String s22 = new String(ch);
            System.out.println();
        }
    }
    //排序子序列 非递增就是整体是递增的但是序列中有相同的元素，非递减序列也是一样的
    public static void main4(String[] args) {
        Scanner scan = new Scanner(System.in);
        while (scan.hasNextInt()) {
            int n = scan.nextInt();
            int[] arr = new int[n + 1];
            for (int i = 0; i < n; i++) {
                arr[i] = scan.nextInt();
            }
            int i = 0;
            int count = 0;
            while (i < n) {
                if (arr[i] < arr[i + 1]) {
                    while (i < n && arr[i] < arr[i + 1]) i++;
                    count++;
                    i++;
                }else if (arr[i] == arr[i + 1]) {
                    i++;
                }else {
                    while (i < n && arr[i] > arr[i + 1]) i++;
                    count++;
                    i++;
                }
            }
            System.out.println(count);
        }
    }
}
